1、链表的倒数第k个节点及以后数据
思想一：利用快慢指针解决，
思想二：利用vector将指针存储起来，倒数第k个就是size()-k；
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        vector<ListNode*> v;
        while(head)
        {
            v.push_back(head);
            head=head->next;
        }
        return v[v.size()-k];
    }
};

2、根据preorder和inorder创建一棵树；
思想：利用递归思想，先构建根，将构建左子树，在构建右子树，因为preorder的第一个元素绝对是根，在将inorder的数据分成3部分
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* _buildTree(vector<int>& preorder, vector<int>& inorder,int& pbegin,int ibegin,int iend)
    {
        TreeNode* root=new TreeNode(preorder[pbegin]);
        if(ibegin>iend)
        {
            return nullptr;
        }
        
        int cur=0;
        while(preorder[pbegin]!=inorder[cur])
        {
            cur+=1;
        }
        if(cur!=ibegin)
        {
            root->left=_buildTree(preorder,inorder,++pbegin,ibegin,cur-1);
        }
        else
        {
            root->left=nullptr;
        }
        if(cur!=iend)
        {
            root->right=_buildTree(preorder,inorder,++pbegin,cur+1,iend);
        }
        else
        {
            root->right=nullptr;
        }
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)
        {
            return nullptr;
        }
        int pbegin=0;
        int ibegin=0;
        int iend=inorder.size()-1;
        return _buildTree(preorder,inorder,pbegin,ibegin,iend);
    }
};
3、调整数组顺序，使奇数都在前
思想一：创建2个vector，一个放奇数，另一个放偶数，在一合并
思想二：利用快排的左右指针思想，左边找偶数，右边找奇数，互换
class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int left=0;
        int right=nums.size()-1;
        while(left<right)
        {
            //快排思想，左边找偶数，右边找奇数，然后互换
            while(left<right&&(nums[left]%2)!=0)
            {
                left+=1;
            }
            while(left<right&&(nums[right])%2==0)
            {
                right-=1;
            }
           
                int tmp=nums[left];
                nums[left]=nums[right];
                nums[right]=tmp;
            
            
        }
        return nums;
    }
};